Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@br/pkg/storage/BUILD.bazel`:
- Around line 107-111: The BUILD file contains unresolved Git conflict markers
(<<<<<<<, =======, >>>>>>>) around the shard_count setting which breaks Bazel;
remove the conflict markers and leave a single valid shard_count assignment
(choose the intended value—either 45 or 50—or confirm with the author), e.g.,
replace the whole conflicted block with a single line "shard_count =
<chosen_value>," and ensure there are no leftover markers or duplicate entries
for shard_count.

In `@br/pkg/storage/memstore_test.go`:
- Around line 121-124: The test is using store.Open with a wrong type reference:
replace the undefined storeapi.ReaderOption with the local storage package type
by passing &ReaderOption{ StartOffset: &start, EndOffset: &end } (i.e., use
ReaderOption from the same package as Open); update the call at r, err :=
store.Open(ctx, fileName, ...) to construct the correct *ReaderOption type so it
matches the Open signature.

In `@pkg/lightning/mydump/BUILD.bazel`:
- Around line 26-30: Remove the Git merge-conflict markers (<<<<<<<, =======,
>>>>>>>) and merge the dependency entries so the deps list contains the intended
entries (e.g. include both "//pkg/errno" and "//pkg/lightning/backend/external"
as normal strings) without any conflict markers; update the dependency block in
BUILD.bazel where the markers appear and apply the same fix to the other
occurrence noted (lines 58-62) so the file is valid for Bazel parsing.

In `@pkg/lightning/mydump/parquet_parser_test.go`:
- Around line 97-107: Remove all unresolved Git conflict markers in
parquet_parser_test.go and reconcile the two variants into a single consistent
implementation; specifically, replace the conflict block that contains manual
storage.NewLocalStorage/open/NewParquetParser calls with the test helper
newParquetParserForTest(context.Background(), t, dir, name, ParquetFileMeta{})
(and remove the corresponding defer/close duplication) so the test compiles, and
repeat this cleanup for the other listed ranges (156-172, 176-200, 204-240,
325-339, 346-449, 483-488, 518-524, 547-557, 567-573, 642-653), ensuring any
duplicate resource setup (storage.NewLocalStorage, store.Open, NewParquetParser)
is replaced by the helper and remaining code uses the helper’s returned reader
and its Close method.
- Around line 45-46: The test currently calls objstore.NewLocalStorage(dir)
which is undefined because the file imports storage as
"github.com/pingcap/tidb/br/pkg/storage"; replace the incorrect symbol with
storage.NewLocalStorage(dir) (or update the import alias to objstore if you
prefer) so the call matches the imported package; update any other occurrences
of objstore.* in parquet_parser_test.go to storage.* to fix the undefined
reference.

In `@pkg/lightning/mydump/parquet_parser.go`:
- Around line 227-238: The struct rowGroupParser has an unresolved merge
conflict: remove the HEAD fields (storage.ReadSeekCloser, lastOff, skipBuf,
store, path) and adopt the cherry-picked fields for the new design (readers
[]*file.Reader and iterators []iterator); update the rowGroupParser definition
to only include readers and iterators and ensure any uses of the removed fields
are refactored to the new per-column reader/iterator approach (search for
rowGroupParser, readers, iterators, storage.ReadSeekCloser, lastOff, skipBuf,
store, and path to update call sites).
- Around line 29-33: Resolve the merge conflict markers in parquet_parser.go
imports: remove the <<<<<<<, =======, and >>>>>>> lines and ensure both import
paths are present by adding both "github.com/pingcap/tidb/br/pkg/storage" and
"github.com/pingcap/tidb/pkg/lightning/common" in the import block; then run a
build to confirm there are no unused-import errors and adjust usages or add
aliasing if necessary to satisfy references in functions/methods within
parquet_parser.go (e.g., any calls referencing storage or common).
- Around line 372-426: In buildRowGroupParser, the goroutines started via eg.Go
capture the loop variable i and do not respect cancellation on egCtx; fix by
copying the loop index into a local var (e.g., idx := i) before calling eg.Go
and, at the top of each goroutine passed to eg.Go, check egCtx.Done() (return
early with ctx.Err() if canceled) to mirror the cancellation pattern used in
parquet_wrapper.go and schema_import.go; also add a short comment near
eg.SetLimit(8) explaining/justifying why the concurrency limit is 8 (or replace
with a named constant) so the rationale is documented.

In `@pkg/lightning/mydump/parquet_wrapper.go`:
- Around line 27-29: The imports of non-existent packages
"github.com/pingcap/tidb/pkg/objstore" and
"github.com/pingcap/tidb/pkg/objstore/storeapi" in parquet_wrapper.go should be
replaced with "br/pkg/storage"; update any references that rely on
ExternalStorage, ReaderOption, and ReadDataInRange to use the equivalents from
br/pkg/storage (they have the same names), and adjust import blocks wherever
those two old imports appear (other occurrences around the file: the other
import groups referenced in the review). Specifically, replace the two imports
at the top and update any code calling ReadDataInRange, using ExternalStorage or
ReaderOption to reference br/pkg/storage so the file compiles.

In `@pkg/lightning/mydump/parquet_writer.go`:
- Around line 56-84: The function writeParquetColumnBatch uses unchecked type
assertions (e.g., buf, _ := vals.([]int64)) which can yield nil/zero buffers and
corrupt output; update each case (for types like *file.Int96ColumnChunkWriter,
*file.Int64ColumnChunkWriter, *file.Float64ColumnChunkWriter,
*file.ByteArrayColumnChunkWriter, *file.FixedLenByteArrayColumnChunkWriter,
*file.Int32ColumnChunkWriter, *file.BooleanColumnChunkWriter) to perform the
comma-ok assertion (buf, ok := vals.([]T)) and if ok is false return a clear
error (e.g., fmt.Errorf("expected []T for %T but got %T", bufType, cw, vals))
instead of calling WriteBatch with a nil buffer, otherwise call WriteBatch(buf,
defLevels, nil) and propagate its error.

---

Outside diff comments:
In `@br/pkg/storage/BUILD.bazel`:
- Around line 89-130: The BUILD change in br/pkg/storage/BUILD.bazel (the
storage_test rule where shard_count was modified) requires regenerated Bazel
metadata; run make bazel_prepare from the repo root to refresh generated Bazel
files, verify changes (including any touched metadata for the storage package),
and add/commit the resulting generated files to this PR so the BUILD.bazel edit
is accompanied by updated Bazel metadata.

In `@pkg/lightning/mydump/BUILD.bazel`:
- Around line 3-125: The BUILD change added/modified dependencies for the
go_library target named "mydump" and the go_test target "mydump_test" but the
generated Bazel metadata is missing; run "make bazel_prepare" locally to
regenerate Bazel metadata and commit the produced changes (the updated generated
files) into this PR so the BUILD changes and generated metadata stay in sync.

In `@pkg/lightning/mydump/parquet_parser.go`:
- Around line 294-322: Remove the leftover conflicting parquetFileWrapper
methods (Seek, Write, Open) from this hunk and keep the new rowGroupParser.Close
implementation that uses common.OnceError; specifically delete the
parquetFileWrapper.Seek, parquetFileWrapper.Write and parquetFileWrapper.Open
blocks and ensure the retained function is the rowGroupParser.Close that
iterates rgp.iterators and rgp.readers and returns onceErr.Get(), preserving the
common.OnceError usage.
- Around line 598-621: Remove the leftover OpenParquetReader function and its
associated references (the symbol OpenParquetReader and the parquetFileWrapper
initialization in this diff) because the new row-group-based architecture no
longer uses the Parquet-specific path; ensure callers are updated to use the new
reader creation path (or the generic store.Open return) and delete the
OpenParquetReader declaration and any unused parquetFileWrapper-only fields to
avoid the unresolved merge conflict.
- Around line 652-670: There is a leftover merge conflict in NewParquetParser:
decide and implement the correct wrapper type (parquetWrapper vs
parquetFileWrapper), remove the conflict markers, and make the initialization
match the rest of the function: if the new architecture expects parquetWrapper,
replace the HEAD block with logger := log.Wrap(logutil.Logger(ctx)); wrapper :=
&parquetWrapper{ReadSeekCloser: r} and add defer r.Close(); if the code expects
parquetFileWrapper, keep the HEAD initialization (including store, ctx, path,
skipBuf) and use logger := logutil.Logger(ctx) without the deferred close;
ensure the chosen wrapper variable name and type (parquetWrapper or
parquetFileWrapper) match all subsequent uses in NewParquetParser and remove the
git conflict markers.
- Around line 710-732: Remove the obsolete per-column reader initialization loop
that creates subreaders (the block referencing subreaders := make(...), the for
i := 1; i < fileSchema.NumColumns(); i++ loop, wrapper.Open(), and repeated
file.NewParquetReader calls); the new design constructs per-column readers on
demand via buildRowGroupParser(), so delete that entire loop and any variables
only used by it (e.g., subreaders) and ensure the initial reader remains if
needed by buildRowGroupParser().

---

Nitpick comments:
In `@pkg/lightning/mydump/parquet_parser.go`:
- Around line 449-456: The fallback builder returned by getBuilder should check
for context cancellation before calling newParquetWrapper; modify the anonymous
function that returns (readerAtSeekerCloser, error) to first inspect ctx (e.g.,
select on ctx.Done() or check ctx.Err()) and return an appropriate error if
cancelled, then proceed to call newParquetWrapper(pp.store, pp.path,
&storeapi.ReaderOption{StartOffset: &ranges.columnStarts[c], EndOffset:
&ranges.columnEnds[c]}) when the context is still valid; keep using the same ctx
variable, and ensure any returned error propagates the context cancellation
(ctx.Err()) rather than proceeding with the wrapper creation.